import 'dart:convert';
import 'dart:io';
import 'package:dio/dio.dart' as dio;
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:xiaofanshu_flutter/mapper/draft_notes_mapper.dart';
import 'package:xiaofanshu_flutter/model/draft_notes.dart';
import 'package:xiaofanshu_flutter/model/response.dart';
import 'package:xiaofanshu_flutter/utils/comment_util.dart';
import 'package:xiaofanshu_flutter/utils/loading_util.dart';
import 'package:xiaofanshu_flutter/utils/snackbar_util.dart';
import '../apis/app.dart';
import '../model/user.dart';
import '../static/custom_code.dart';
import '../static/default_data.dart';
import '../utils/store_util.dart';

class PublishNotesController extends GetxController {
  var isShowAtUser = false.obs;
  var isShowEmoji = false.obs;
  var attentionPage = 1.obs;
  var attentionPageSize = 10.obs;
  var attentionIsLoadMore = false.obs;
  var attentionHasMore = true.obs;
  var attentionList = List.empty().obs;

  // 0为图文，1为视频
  var type = 0.obs;

  // 仅在type为0时使用
  var files = List<File>.empty().obs;

  // 仅在type为1时使用
  Rx<File> video = File('').obs;
  Rx<File> cover = File('').obs;
  var selectedLocationName = ''.obs;
  var longitude = 0.0.obs;
  var latitude = 0.0.obs;
  var authority = 0.obs;
  var userInfo = DefaultData.user.obs;
  var isDraft = false.obs;
  var isEdit = false.obs; // 是否为编辑模式
  var editNotesId = 0; // 编辑的笔记ID
  var draftId = 0;
  var parentNotesId = 0; // 父文章ID（用于续写）
  var isContinuation = false.obs; // 是否为续写模式
  var allowContinuation = true.obs; // 是否允许续写（默认允许）
  var categories = <Map<String, dynamic>>[].obs; // 分类列表
  var selectedCategoryId = 0.obs; // 选中的分类ID
  var selectedCategoryName = ''.obs; // 选中的分类名称
  var isPublishing = false.obs; // 是否正在发布中，用于防止重复提交
  TextEditingController titleController = TextEditingController();
  TextEditingController contentController = TextEditingController();
  ScrollController attentionScrollController = ScrollController();

  @override
  Future<void> onInit() async {
    // TODO: implement onInit
    super.onInit();
    Map<String, dynamic> args = Get.arguments;
    Get.log(args.toString());
    
    // 先判断是否为编辑模式
    if (args.containsKey('isEdit') && args['isEdit'] == true) {
      isEdit.value = true;
      editNotesId = args['notesData']['id'];
      // 延迟到下一帧执行，避免在构建过程中调用LoadingUtil
      WidgetsBinding.instance.addPostFrameCallback((_) {
        loadEditNotesDataFromApi(editNotesId);
      });
    }
    // 再判断是否含有 draft 参数，如果有则说明是草稿
    else if (args.containsKey('draft')) {
      args['draft'] == true ? isDraft.value = true : isDraft.value = false;
      if (isDraft.value) {
        draftId = args['id'];
        DraftNotesMapper.queryById(args['id']).then((value) {
          if (value != null) {
            titleController.text = value.title!;
            contentController.text = value.content!;
            type.value = value.type;
            if (type.value == 0) {
              List<String> filesPath = value.filesPath.split(',');
              for (var item in filesPath) {
                files.add(File(item));
              }
            } else {
              video.value = File(value.filesPath.split(',')[0]);
              cover.value = File(value.coverPath!);
            }
            selectedLocationName.value = value.address!;
            authority.value = value.authority;
            // 加载分类信息
            if (value.categoryId != null) {
              selectedCategoryId.value = value.categoryId!;
            }
          }
        });
      }
    } else {
      type.value = args['type'];
      if (type.value == 0) {
        // 安全的类型转换：确保是 List<File> 类型
        final filesList = args['files'];
        if (filesList is List) {
          files.value = List<File>.from(filesList);
        } else {
          files.value = [];
        }
      } else if (type.value == 1) {
        video.value = args['video'];
        cover.value = args['cover'];
      }
    }
    
    // 检查是否为续写模式（存在parentNotesId参数）
    if (args.containsKey('parentNotesId')) {
      parentNotesId = args['parentNotesId'];
      isContinuation.value = true;
      
      // 生成续集标题
      if (args.containsKey('parentTitle')) {
        String parentTitle = args['parentTitle'] ?? '';
        String continuationTitle = _generateContinuationTitle(parentTitle);
        titleController.text = continuationTitle;
        Get.log('📝 自动生成续集标题: $continuationTitle');
      }
      
      // 继承父文章的属性
      if (args.containsKey('categoryId')) {
        selectedCategoryId.value = args['categoryId'];
      }
      if (args.containsKey('categoryName')) {
        selectedCategoryName.value = args['categoryName'];
      }
      if (args.containsKey('address')) {
        selectedLocationName.value = args['address'];
      }
      if (args.containsKey('longitude')) {
        longitude.value = 0.0;
      }
      if (args.containsKey('latitude')) {
        latitude.value = 0.0;
      }
      
      Get.log('📝 续写模式启用');
      Get.log('   父文章ID: $parentNotesId');
      Get.log('   继承分类: ${selectedCategoryName.value} (ID: ${selectedCategoryId.value})');
      Get.log('   继承地址: ${selectedLocationName.value}');
      Get.log('   继承坐标: (${latitude.value}, ${longitude.value})');
    }
    userInfo.value = User.fromJson(
        jsonDecode(await readData('userInfo') ?? jsonEncode(DefaultData.user)));
    userInfo.refresh();
    String location = await getLocation();
    Get.log('位置信息：$location');
    List<String> locationList = location.split(',');
    longitude.value = double.parse(locationList[1]);
    latitude.value = double.parse(locationList[0]);
    
    // 加载分类数据
    await loadCategories();
    
    loadAttentionList();
    attentionScrollController.addListener(() {
      if (attentionScrollController.offset ==
          attentionScrollController.position.maxScrollExtent) {
        loadAttentionList();
      }
    });
    titleController.addListener(() {
      // 禁止输入换行
      if (titleController.text.contains('\n')) {
        titleController.text = titleController.text.replaceAll('\n', '');
        titleController.selection = TextSelection.fromPosition(
            TextPosition(offset: titleController.text.length));
      }
    });
    contentController.addListener(() {
      // 不能连续输入3个换行
      if (contentController.text.contains('\n\n\n')) {
        contentController.text =
            contentController.text.replaceAll('\n\n\n', '\n\n');
        contentController.selection = TextSelection.fromPosition(
            TextPosition(offset: contentController.text.length));
      }
    });
  }

  /// 通过API加载编辑笔记数据
  Future<void> loadEditNotesDataFromApi(int notesId) async {
    try {
      LoadingUtil.show();
      HttpResponse httpResponse = await NoteApi.getNotesDetail(notesId);
      LoadingUtil.hide();
      
      if (httpResponse.code == StatusCode.getSuccess) {
        Map<String, dynamic> notesData = httpResponse.data;
        await loadEditNotesData(notesData);
      } else {
        SnackbarUtil.showError('获取笔记详情失败：${httpResponse.msg}');
      }
    } catch (e) {
      LoadingUtil.hide();
      SnackbarUtil.showError('获取笔记详情失败：$e');
    }
  }

  /// 加载编辑笔记数据
  Future<void> loadEditNotesData(Map<String, dynamic> notesData) async {
    try {
      // 设置基本信息
      titleController.text = notesData['title'] ?? '';
      contentController.text = notesData['content'] ?? '';
      type.value = notesData['type'] ?? 0;
      authority.value = notesData['authority'] ?? 0;
      selectedLocationName.value = notesData['address'] ?? '';
      
      // 设置分类信息
      if (notesData['categoryId'] != null) {
        selectedCategoryId.value = notesData['categoryId'];
        // 从分类列表中找到对应的分类名称
        for (var category in categories) {
          if (category['id'] == notesData['categoryId']) {
            selectedCategoryName.value = category['name'];
            break;
          }
        }
      }
      
      // 根据类型设置媒体文件
      if (type.value == 0) {
        // 图片类型
        if (notesData['notesResources'] != null) {
          List<dynamic> resources = notesData['notesResources'];
          files.clear();
          for (var resource in resources) {
            // 这里需要下载网络图片到本地文件
            // 暂时先清空，用户需要重新选择图片
            // TODO: 实现网络图片下载到本地
          }
        }
      } else if (type.value == 1) {
        // 视频类型
        if (notesData['notesResources'] != null && notesData['notesResources'].isNotEmpty) {
          // 这里需要下载网络视频到本地文件
          // 暂时先清空，用户需要重新选择视频
          // TODO: 实现网络视频下载到本地
        }
      }
    } catch (e) {
      Get.log('加载编辑笔记数据失败: $e');
    }
  }

  void loadAttentionList() {
    if (attentionIsLoadMore.value) {
      return;
    }
    attentionIsLoadMore.value = true;
    if (!attentionHasMore.value) {
      attentionIsLoadMore.value = false;
      return;
    }
    UserApi.getAttentionList(
            userInfo.value.id, attentionPage.value, attentionPageSize.value)
        .then((value) {
      if (value.code == StatusCode.getSuccess) {
        for (var item in value.data) {
          attentionList.add(item);
        }
        attentionPage.value++;
        if (value.data.length < attentionPageSize.value) {
          attentionHasMore.value = false;
        }
      }
    }).whenComplete(() {
      attentionIsLoadMore.value = false;
    });
  }

  // 加载分类数据
  Future<void> loadCategories() async {
    try {
      HttpResponse response = await NoteApi.getNoteCategory();
      if (response.code == StatusCode.getSuccess) {
        categories.value = List<Map<String, dynamic>>.from(response.data);
        Get.log('成功加载分类数据: ${categories.length}个分类');

      } else {
        Get.log('获取分类数据失败: ${response.msg}');
      }
    } catch (e) {
      Get.log('获取分类数据出错: $e');
    }
  }

  Future<void> publish() async {
    // 防止重复提交
    if (isPublishing.value) {
      Get.log('正在发布中，请勿重复点击');
      return;
    }
    
    // 表单验证
    if (titleController.text.isEmpty) {
      SnackbarUtil.showError('请输入标题');
      return;
    }
    if (contentController.text.isEmpty) {
      SnackbarUtil.showError('请输入内容');
      return;
    }
    if (type.value == 0 && files.isEmpty) {
      SnackbarUtil.showError('请上传图片');
      return;
    }
    if (type.value == 1 && video.value.path.isEmpty) {
      SnackbarUtil.showError('请上传视频');
      return;
    }
    if (type.value == 1 && cover.value.path.isEmpty) {
      SnackbarUtil.showError('请上传封面');
      return;
    }
    
    // 设置发布状态为true，禁用发布按钮
    isPublishing.value = true;
    LoadingUtil.show();
    
    try {
      List<String> filesPath = [];
      String coverPath = '';
      
      // 上传资源
      if (type.value == 0) {
        // 上传图片
        for (var element in files) {
          File file = File(element.path);
          dio.FormData formData = dio.FormData.fromMap({
            'file': await dio.MultipartFile.fromFile(
              file.path,
              filename: file.path.split('/').last,
            ),
          });
          HttpResponse httpResponse = await ThirdApi.uploadImage(formData);
          if (httpResponse.code == StatusCode.postSuccess) {
            filesPath.add(httpResponse.data);
          } else {
            throw Exception('图片上传失败：${httpResponse.msg}');
          }
        }
      } else {
        // 上传视频
        File file = File(video.value.path);
        dio.FormData formData = dio.FormData.fromMap({
          'file': await dio.MultipartFile.fromFile(
            file.path,
            filename: file.path.split('/').last,
          ),
        });
        HttpResponse httpResponse = await ThirdApi.uploadVideo(formData);
        if (httpResponse.code == StatusCode.postSuccess) {
          filesPath.add(httpResponse.data);
        } else {
          throw Exception('视频上传失败：${httpResponse.msg}');
        }
        
        // 上传封面
        File coverFile = File(cover.value.path);
        dio.FormData coverFormData = dio.FormData.fromMap({
          'file': await dio.MultipartFile.fromFile(
            coverFile.path,
            filename: coverFile.path.split('/').last,
          ),
        });
        HttpResponse coverHttpResponse = await ThirdApi.uploadImage(coverFormData);
        if (coverHttpResponse.code == StatusCode.postSuccess) {
          coverPath = coverHttpResponse.data;
        } else {
          throw Exception('封面上传失败：${coverHttpResponse.msg}');
        }
      }
      
      // 构建提交数据
      String jsonResource = jsonEncode(filesPath);
      Map<String, dynamic> data = {
        'title': titleController.text,
        'content': contentController.text,
        'realContent': contentController.text,
        'belongUserId': userInfo.value.id,
        'notesType': type.value,
        'coverPicture': type.value == 0 ? '' : coverPath,
        'notesResources': jsonResource,
        'address': selectedLocationName.value,
        'longitude': longitude.value,
        'latitude': latitude.value,
        'authority': authority.value,
        'allowContinuation': allowContinuation.value ? 1 : 0, // 是否允许续写
      };
      
      // 如果选择了分类，才添加分类参数
      if (selectedCategoryId.value > 0) {
        data['belongCategory'] = selectedCategoryId.value;
      }
      
      // 如果是续写模式，特殊处理
      if (parentNotesId > 0) {
        data['parentNotesId'] = parentNotesId;
        
        // 续写文章：地理坐标设为0避免重复标记
        data['longitude'] = 0.0; // 设为0，避免地图重复标记
        data['latitude'] = 0.0;  // 设为0，避免地图重复标记
        
        // 分类处理：如果父文章有分类则继承，否则使用用户选择的分类
        if (selectedCategoryId.value > 0) {
          data['belongCategory'] = selectedCategoryId.value;
          Get.log('📝 续写模式发布配置:');
          Get.log('   父文章ID: $parentNotesId');
          Get.log('   继承分类: ${selectedCategoryName.value} (ID: ${selectedCategoryId.value})');
          Get.log('   地理坐标: (0.0, 0.0) - 避免重复标记');
        } else {
          Get.log('⚠️ 续写模式：父文章没有分类，使用用户选择的分类');
          Get.log('   父文章ID: $parentNotesId');
          Get.log('   用户选择分类: ${selectedCategoryName.value} (ID: ${selectedCategoryId.value})');
          Get.log('   地理坐标: (0.0, 0.0) - 避免重复标记');
        }
      }
      
      // 根据是否为编辑模式调用不同的API
      HttpResponse response;
      if (isEdit.value) {
        // 编辑模式，添加笔记ID
        data['notesId'] = editNotesId;
        response = await NoteApi.updateNotes(data);
      } else {
        // 发布模式
        response = await NoteApi.publishNotes(data);
      }
      
      // 隐藏加载动画
      LoadingUtil.hide();
      
      // 处理响应
      if ((isEdit.value && response.code == StatusCode.putSuccess) ||
          (!isEdit.value && response.code == StatusCode.postSuccess)) {
        SnackbarUtil.showInfo(isEdit.value ? '修改成功' : '发布成功');
        // 延迟1.5秒后关闭页面，让用户看到成功提示
        await Future.delayed(const Duration(milliseconds: 1500));
        Get.back();
      } else {
        // 发布失败，恢复发布状态
        isPublishing.value = false;
        SnackbarUtil.showError(isEdit.value ? '修改失败：${response.msg}' : '发布失败：${response.msg}');
      }
    } catch (e) {
      // 发生异常，恢复发布状态
      LoadingUtil.hide();
      isPublishing.value = false;
      Get.log('发布笔记失败: $e');
      SnackbarUtil.showError('操作失败：$e');
    }
  }

  /// 生成续集标题
  /// 规则：
  /// 1. 如果原标题中有"续集X"格式，则将X+1
  /// 2. 如果原标题中没有"续集"，则添加"续集1"
  String _generateContinuationTitle(String parentTitle) {
    if (parentTitle.isEmpty) {
      return '续集1';
    }
    
    // 使用正则表达式匹配"续集+数字"的模式
    // 支持：续集1、续集2、续集10等格式
    RegExp regExp = RegExp(r'续集(\d+)');
    Match? match = regExp.firstMatch(parentTitle);
    
    if (match != null) {
      // 找到了"续集X"的格式
      String numberStr = match.group(1)!;
      int currentNumber = int.parse(numberStr);
      int nextNumber = currentNumber + 1;
      
      // 替换原来的数字
      String newTitle = parentTitle.replaceFirst(regExp, '续集$nextNumber');
      return newTitle;
    } else {
      // 没有找到"续集X"的格式，直接在标题后面添加"续集1"
      return '$parentTitle 续集1';
    }
  }

  Future<void> saveDraft() async {
    LoadingUtil.show();
    // 将 files 列表转换为逗号分隔的字符串
    String filesPathString = type.value == 0
        ? files.map((e) => e.path).join(',')
        : [video.value.path, cover.value.path].join(',');
// 创建 DraftNotes 实例
    DraftNotes draftNotes = DraftNotes(
      title: titleController.text,
      content: contentController.text,
      type: type.value,
      // 确保这是整数
      filesPath: filesPathString,
      // 转换为字符串
      coverPath: type.value == 0 ? '' : cover.value.path,
      authority: authority.value,
      // 确保这是整数
      address: selectedLocationName.value,
      categoryId: selectedCategoryId.value > 0 ? selectedCategoryId.value : null, // 分类ID可选
    );
    if (isDraft.value) {
      await DraftNotesMapper.delete(draftId);
    }
    var i = await DraftNotesMapper.insert(draftNotes);
    LoadingUtil.hide();
    if (i > 0) {
      SnackbarUtil.showSuccess('保存成功');
    } else {
      SnackbarUtil.showError('保存失败');
    }
    Get.back();
  }
}
